home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 9 / Night Owl CD-ROM (NOPV9) (Night Owl Publisher) (1993).ISO / 001a / seyon213.tz / seyon213 / seyon / SeSet.c < prev    next >
C/C++ Source or Header  |  1993-04-09  |  15KB  |  696 lines
  1.  
  2.  
  3. /*
  4.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  5.  * Saggaf. All rights reserved.
  6.  *
  7.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  8.  * statement of rights and permissions for this program.
  9. */
  10.  
  11. #include <math.h>
  12.  
  13. #include <X11/Intrinsic.h>
  14. #include <X11/StringDefs.h>
  15.  
  16. #include <X11/Xaw/Toggle.h>
  17. #include <X11/Xaw/Dialog.h>
  18.  
  19. #include "seyon.h"
  20. #include "SeDecl.h"
  21.  
  22. extern int      param_pipe[2];
  23.  
  24. int             DetNewlineTrMode(),
  25.                 ToggleNewlineMode(),
  26.                 SetIStrip(),
  27.                 ToggleDelMode(),
  28.                 ToggleMetaKeyTr(),
  29.                 ToggleXOffMode(),
  30.                 ToggleRtsctsMode(),
  31.                 ToggleZmodemAutoDownload(),
  32.                 ToggleIdleGuard(),
  33.                 MenuSetGetBaud(),
  34.                 MenuSetGetCSize(),
  35.                 MenuSetGetParity(),
  36.                 MenuSetGetStopBits(),
  37.                 MenuSetGetParamSCut(),
  38.                 MenuSetGetNewlineTrMode();
  39. void            UpdateToggleSettings(),
  40.                 UpdateStates(),
  41.                 SetGetRadioVal(),
  42.                 SetDoGetRadioVal(),
  43.                 SetGetValue(),
  44.                 SetDoGetValue();
  45. Boolean         SetBaud(),
  46.                 SetPort();
  47.  
  48. int             newlineTrMode;
  49.  
  50. struct _setToggle {
  51.   Widget          widget;
  52.   char           *name;
  53.   int             state;
  54.   int            (*call_back) ();
  55. };
  56.  
  57. struct _setRadio {
  58.   String          name;
  59.   String          button[10];
  60.   int             activeIndex;
  61.   int             (*call_back) ();
  62. };
  63.  
  64. struct _setValue {
  65.   char           *name;
  66.   char            value[SM_BUF];
  67.                   Boolean(*call_back) ();
  68. };
  69.  
  70. static struct _setToggle set_toggle[] =
  71. {
  72.   {NULL, "stripHighBit", 0, SetIStrip},
  73.   {NULL, "del", 0, ToggleDelMode},
  74.   {NULL, "meta_tr", 0, ToggleMetaKeyTr},
  75.   {NULL, "xoff", 0, ToggleXOffMode},
  76.   {NULL, "rtscts", 0, ToggleRtsctsMode},
  77.   {NULL, "autozm", 0, ToggleZmodemAutoDownload},
  78.   {NULL, "idle", 0, ToggleIdleGuard},
  79.   {NULL, NULL, 0, NULL}
  80. };
  81.  
  82. static struct _setRadio setRadio[] =
  83. {
  84.   {"baud", {"300", "1200", "2400", "4800", "9600", "19200", "38400",
  85. #if USE_NONSTD_BAUD
  86.     "56700", "115200",
  87. #endif
  88.     NULL}, 1, MenuSetGetBaud},
  89.   {"bits", {"5", "6", "7", "8", NULL}, 1, MenuSetGetCSize},
  90.   {"parity", {"none", "odd", "even", NULL}, 1, MenuSetGetParity},
  91.   {"stopBits", {"1", "2", NULL}, 1, MenuSetGetStopBits},
  92.   {"cut", {"8n1", "7e1", "other", NULL}, 1, MenuSetGetParamSCut},
  93.   {"nl_tr", {"nl", "cr", "cr_lf", NULL}, 1, MenuSetGetNewlineTrMode},
  94.   {NULL, {NULL}, 0, NULL}
  95. };
  96.  
  97. static struct _setValue set_value[] =
  98. {
  99.   {"port", "", SetPort},
  100.   {NULL, "", NULL}
  101. };
  102.  
  103. struct _setRadio *curRadObjPtr;
  104. struct _setValue *curValObjPtr;
  105.  
  106. void
  107. TopSet(w)
  108.      Widget          w;
  109. {
  110.   Widget          popup,
  111.                   mBox,
  112.                   uBox,
  113.                   lBox;
  114.   struct _setToggle *tptr;
  115.   struct _setRadio *rPtr;
  116.   struct _setValue *vptr;
  117.  
  118.   ErrorIfBusy()
  119.  
  120.   tptr = set_toggle;
  121.   tptr->state = qres.stripHighBit; tptr++;
  122.   tptr->state = qres.backspaceTranslation; tptr++;
  123.   tptr->state = qres.metaKeyTranslation; tptr++;
  124.   tptr->state = qres.xonxoffFlowControl; tptr++;
  125.   tptr->state = qres.rtsctsFlowControl; tptr++;
  126.   tptr->state = qres.autoZmodem; tptr++;
  127.   tptr->state = qres.idleGuard; tptr++;
  128.  
  129.   popup = SeAddPopup("set", w);
  130.   mBox = SeAddPaned("mBox", popup);
  131.   uBox = SeAddBox("uBox", mBox);
  132.   lBox = SeAddBox("lBox", mBox);
  133.  
  134.   for (tptr = set_toggle; tptr->name != NULL; tptr++) {
  135.     tptr->widget = SeAddToggleWCD(tptr->name, uBox, UpdateToggleSettings,
  136.                                   (XtPointer)(tptr->call_back));
  137.     SeSetUnsetToggle(tptr->widget, tptr->state);
  138.   }
  139.  
  140.   for (rPtr = setRadio; rPtr->name != NULL; rPtr++)
  141.     SeAddButtonWCD(rPtr->name, uBox, SetGetRadioVal, (XtPointer) rPtr);
  142.  
  143.   for (vptr = set_value; vptr->name != NULL; vptr++)
  144.     SeAddButtonWCD(vptr->name, uBox, SetGetValue, (XtPointer) vptr);
  145.  
  146.   SeAddButtonWCD("dismiss", lBox, DestroyShellCallBack, (XtPointer) mBox);
  147.  
  148.   XtPopup(popup, XtGrabExclusive);
  149. }
  150.  
  151. void
  152. SetGetRadioVal(widget, client_data)
  153.      Widget          widget;
  154.      XtPointer       client_data;
  155. {
  156.   struct _setRadio *rPtr = (struct _setRadio*)client_data;
  157.  
  158.   rPtr->activeIndex = (*rPtr->call_back)(-1);
  159.   SePopupRadio(rPtr->name, widget, rPtr->button, rPtr->activeIndex,
  160.                SetDoGetRadioVal, (XtPointer)rPtr);
  161. }
  162.  
  163. void
  164. SetDoGetRadioVal(widget, client_data)
  165.      Widget          widget;
  166.      XtPointer       client_data;
  167. {
  168.   int   TerminalRefreshParameters();
  169.  
  170.   struct _setRadio *rPtr = (struct _setRadio *)client_data;
  171.   Boolean         state;
  172.  
  173.   XtVaGetValues(widget, XtNradioData, &(rPtr->activeIndex), XtNstate,
  174.         &state, NULL);
  175.  
  176.   /* The callback routine is called both when the widget is set or unset,
  177.      so we make sure we do nothing if the widget is unset */
  178.   if (state == False)
  179.     return;
  180.  
  181.   (void)(*rPtr->call_back) (rPtr->activeIndex);
  182.   TerminalRefreshParameters();
  183.   SeyonMessage("Parameter Change Performed");
  184. }
  185.  
  186. void
  187. SetGetValue(widget, client_data)
  188.      Widget          widget;
  189.      XtPointer       client_data;
  190. {
  191.   struct _setValue *vptr;
  192.  
  193.   vptr = set_value;
  194.   strcpy(vptr->value, modem_port);
  195.   vptr++;
  196.  
  197.   curValObjPtr = (vptr = (struct _setValue *)client_data);
  198.   SePopupDialogGetStringE("set_value", widget, SetDoGetValue,
  199.               client_data, vptr->value, True);
  200. }
  201.  
  202. void
  203. SetDoGetValue(widget, client_data)
  204.      Widget          widget;
  205.      XtPointer       client_data;
  206. {
  207.   int   TerminalRefreshParameters();
  208.  
  209.   Widget          dialog = XtParent(widget);
  210.   struct _setValue *vptr = (struct _setValue *)client_data;
  211.  
  212.   str_stripspc_copy(vptr->value, XawDialogGetValueString(dialog));
  213.   DestroyParentPopup(NULL, dialog, NULL);
  214.   (void)(*vptr->call_back) (vptr->value);
  215.   TerminalRefreshParameters();
  216.   SeyonMessage("Parameter Change Performed");
  217. }
  218.  
  219. void
  220. setVal_action_ok(widget)
  221.      Widget          widget;
  222. {
  223.   SetDoGetValue(widget, (XtPointer) curValObjPtr);
  224. }
  225.  
  226. void
  227. UpdateToggleSettings(widget, clientData)
  228.      Widget          widget;
  229.      XtPointer       clientData;
  230. {
  231.   int   TerminalRefreshParameters();
  232.  
  233.   /* We have to complicate things a bit to avoid the danger of the case
  234.      SeGetTog.. = True = -1. One should not assume True = 1*/
  235.   ((void (*)())clientData)(SeGetToggleState(widget) ? 1 : 0);
  236.   TerminalRefreshParameters();
  237.   SeyonMessage("Parameter Change Performed");
  238. }
  239.  
  240. int
  241. SetIStrip(state)
  242.      int state;
  243. {
  244.   qres.stripHighBit = (Boolean)state;
  245.   return MdmSetGetIStrip(state);
  246. }
  247.  
  248. int
  249. ToggleDelMode()
  250. {
  251.   toggle_flag(&(qres.backspaceTranslation));
  252.   return 0;
  253. }
  254.  
  255. int
  256. ToggleMetaKeyTr()
  257. {
  258.   toggle_flag(&(qres.metaKeyTranslation));
  259.   return 0;
  260. }
  261.  
  262. int
  263. ToggleXOffMode()
  264. {
  265.   toggle_flag(&(qres.xonxoffFlowControl));
  266.   xc_setflow();
  267.   return 0;
  268. }
  269.  
  270. int
  271. ToggleRtsctsMode()
  272. {
  273.   toggle_flag(&(qres.rtsctsFlowControl));
  274.   set_rtscts();
  275.   return 0;
  276. }
  277.  
  278. int
  279. ToggleZmodemAutoDownload()
  280. {
  281.   toggle_flag(&(qres.autoZmodem));
  282.   return 0;
  283. }
  284.  
  285. int
  286. ToggleIdleGuard()
  287. {
  288.   toggle_flag(&(qres.idleGuard));
  289.   IdleGuard();
  290.   return 0;
  291. }
  292.  
  293. int
  294. DetNewlineTrMode(keyword)
  295.      String          keyword;
  296. {
  297.   char            kw[SM_BUF];
  298.  
  299.   if ((keyword == NULL) || (*keyword == '\0')) {
  300.     SeError("missing newlineTranslation keyword");
  301.     return -1;
  302.   }
  303.  
  304.   str_stripspc_copy(kw, keyword);
  305.   lc_word(kw);
  306.   if (strcmp(kw, "nl") == 0)
  307.     return 1;
  308.   else if (strcmp(kw, "cr") == 0)
  309.     return 2;
  310.   else if (strcmp(kw, "cr/lf") == 0)
  311.     return 3;
  312.   else {
  313.     SeErrorF("illigal newlineTranslation keyword: %s", keyword, "", "");
  314.     return -1;
  315.   }
  316. }
  317.  
  318. void
  319. SetNewlineTrMode(keyword)
  320.      String          keyword;
  321. {
  322.   if ((newlineTrMode = DetNewlineTrMode(keyword)) < 0)
  323.     newlineTrMode = 2;
  324. }
  325.  
  326. int
  327. MenuSetGetNewlineTrMode(trMode)
  328.      int             trMode;
  329. {
  330.   if (trMode != -1)
  331.     newlineTrMode = trMode;
  332.   return newlineTrMode;
  333. }
  334.  
  335. void
  336. SetScrNewlineTrMode()
  337. {
  338.   getword();
  339.   if (word[0] == '\0') {
  340.     SeError("'set newlineTranslation' must specify translation mode");
  341.     eof_flag++;
  342.     return;
  343.   }
  344.  
  345.   SetNewlineTrMode(word);
  346. }
  347.  
  348. int
  349. MenuSetGetBaud(baudIndex)
  350.      int             baudIndex;
  351. {
  352.   return MdmSetGetBaud(baudIndex);
  353. }
  354.  
  355. int
  356. MenuSetGetCSize(bitsIndex)
  357.      int             bitsIndex;
  358. {
  359.   return MdmSetGetCSize(bitsIndex == -1 ? bitsIndex :
  360.             bitsIndex + 4) - 4;
  361. }
  362.  
  363. int
  364. MenuSetGetParity(parityIndex)
  365.      int             parityIndex;
  366. {
  367.   return MdmSetGetParity(parityIndex == -1 ? parityIndex :
  368.              parityIndex - 1) + 1;
  369. }
  370.  
  371. int
  372. MenuSetGetStopBits(bitsIndex)
  373.      int             bitsIndex;
  374. {
  375.   return MdmSetGetStopBits(bitsIndex);
  376. }
  377.  
  378. int
  379. MenuSetGetParamSCut(paramIndex)
  380.      int             paramIndex;
  381. {
  382.   int             bits,
  383.                   parity,
  384.                   stopBits;
  385.  
  386.   if (paramIndex == -1) {
  387.  
  388.     bits = MdmSetGetCSize(-1);
  389.     parity = MdmSetGetParity(-1);
  390.     stopBits = MdmSetGetStopBits(-1);
  391.  
  392.     if (bits == 8 && parity == 0 && stopBits == 1)
  393.       return 1;
  394.     else if (bits == 7 && parity == 2 && stopBits == 1)
  395.       return 2;
  396.     else
  397.       return 3;
  398.   }
  399.  
  400.   if (paramIndex == 1) {
  401.     MdmSetGetCSize(8);
  402.     MdmSetGetParity(0);
  403.     MdmSetGetStopBits(1);
  404.   }
  405.   else if (paramIndex == 2) {
  406.     MdmSetGetCSize(7);
  407.     MdmSetGetParity(2);
  408.     MdmSetGetStopBits(1);
  409.   }
  410.  
  411.   return paramIndex;
  412. }
  413.  
  414. Boolean
  415. SetBaud(baud)
  416.      String          baud;
  417. {
  418.   if (mbaud(baud) < 0) {
  419.     SeErrorF("unsupported baud rate %s", baud, "", "");
  420.     return False;
  421.   }
  422.   return True;
  423. }
  424.  
  425. Boolean
  426. SetPort(port)
  427.      String          port;
  428. {
  429.   int             OpenModem();
  430.   void            ShowOpenModemErrMsg();
  431.  
  432.   int             retStatus;
  433.   String          oldPort = XtNewString(mport(NULL));
  434.  
  435.   unlock_tty();
  436.   close_modem();
  437.  
  438.   if ((retStatus = OpenModem(port)) < 0) {
  439.     ShowOpenModemErrMsg(port, retStatus);
  440.     SeError(FmtString("Could not open new modem device %s", port, "", ""));
  441.  
  442.     if ((retStatus = OpenModem(oldPort)) < 0) {
  443.       ShowOpenModemErrMsg(oldPort, retStatus);
  444.       SeError(FmtString("Could not re-open old modem device %s", oldPort, "", 
  445.                         ""));
  446.     }
  447.  
  448.     XtFree(oldPort);
  449.     return False;
  450.   }
  451.  
  452.   XtFree(oldPort);
  453.   return True;
  454. }
  455.  
  456. void            s_set_xoff(),
  457.                 s_set_baud(),
  458.                 set_port(),
  459.                 s_set_cr(),
  460.                 ScrSetIStrip(),
  461.                 s_set_del(),
  462.                 set_meta_tr(),
  463.                 s_set_rtscts(),
  464.                 s_set_autozm(),
  465.                 SetScrIdleGuardMode(),
  466.                 ScrSetCSize(),
  467.                 ScrSetParity(),
  468.                 ScrSetStopBits();
  469.  
  470. struct kw       setlist[] =
  471. {
  472.   {"stripHighBit", ScrSetIStrip},
  473.   {"bits", ScrSetCSize},
  474.   {"parity", ScrSetParity},
  475.   {"stopBits", ScrSetStopBits},
  476.   {"newlineTranslation", SetScrNewlineTrMode},
  477.   {"del", s_set_del},
  478.   {"meta_tr", set_meta_tr},
  479.   {"xoff", s_set_xoff},
  480.   {"rtscts", s_set_rtscts},
  481.   {"autozm", s_set_autozm},
  482.   {"idleGuard", SetScrIdleGuardMode},
  483.   {"baud", s_set_baud},
  484.   {"port", set_port},
  485.   {NULL, NULL}};
  486.  
  487. void
  488. s_set()
  489. {
  490.   struct kw      *ptr;
  491.  
  492.   GETTEST_ARG("set");
  493.  
  494. /*  lc_word(word);*/
  495.  
  496.   for (ptr = setlist; ptr->keyword != NULL; ptr++)
  497.     if (strcmp(ptr->keyword, word) == 0)
  498.       {(*ptr->rtn)(); return;}
  499.  
  500.   SeErrorF("Invalid set keyword `%s'", word, "", "");
  501.   eof_flag++;
  502. }
  503.  
  504. void
  505. s_set_cr()
  506. {
  507.   set_onoff(&(qres.newlineTranslation));
  508. }
  509.  
  510. void
  511. ScrSetIStrip()
  512. {
  513.   Boolean tmpSetFlag;
  514.  
  515.   set_onoff(&tmpSetFlag);
  516.   SetIStrip(tmpSetFlag ? 1 : 0);
  517. }
  518.  
  519. void
  520. s_set_del()
  521. {
  522.   set_onoff(&(qres.backspaceTranslation));
  523. }
  524.  
  525. void
  526. set_meta_tr()
  527. {
  528.   set_onoff(&(qres.metaKeyTranslation));
  529. }
  530.  
  531. void
  532. s_set_xoff()
  533. {
  534.   set_onoff(&(qres.xonxoffFlowControl));
  535.   xc_setflow();
  536. }
  537.  
  538. void
  539. s_set_rtscts()
  540. {
  541.   set_onoff(&(qres.rtsctsFlowControl));
  542.   set_rtscts();
  543. }
  544.  
  545. void
  546. s_set_autozm()
  547. {
  548.   set_onoff(&(qres.autoZmodem));
  549. }
  550.  
  551. void
  552. SetScrIdleGuardMode()
  553. {
  554.   set_onoff(&(qres.idleGuard));
  555.   IdleGuard();
  556. }
  557.  
  558. void
  559. set_onoff(flag)
  560.      Boolean        *flag;
  561. {
  562.   String          keyWord = XtNewString(word);
  563.  
  564.   getword();
  565.   lc_word(word);
  566.  
  567.   if (strcmp(word, "on") == 0) *flag = True;
  568.   else if (strcmp(word, "off") == 0) *flag = False;
  569.   else {
  570.     SeErrorF("Argument `%s' to keyword `%s' is neither on nor off", 
  571.              word, keyWord, "");
  572.     eof_flag++;
  573.   }
  574.  
  575.   if (keyWord) XtFree(keyWord);
  576. }
  577.  
  578. #define ScrGetArg(msg) \
  579. { \
  580.   getword(); \
  581.   if (word[0] == '\0') { \
  582.     SeError(msg); \
  583.     eof_flag++; \
  584.     return; \
  585.   } \
  586. }
  587.  
  588. void
  589. ScrSetCSize()
  590. {
  591.   ScrGetArg("set bits: missing argument");
  592.   MdmSetGetCSize(atoi(word));
  593. }
  594.  
  595. void
  596. ScrSetParity()
  597. {
  598.   ScrGetArg("set parity: missing argument");
  599.   MdmSetGetParity(atoi(word));
  600. }
  601.  
  602. void
  603. ScrSetStopBits()
  604. {
  605.   ScrGetArg("set stopBits: missing argument");
  606.   MdmSetGetStopBits(atoi(word));
  607. }
  608.  
  609. void
  610. s_set_baud()
  611. {
  612.   getword();
  613.   if (word[0] == '\0') {
  614.     SeError("'set baud' must specify baud rate");
  615.     eof_flag++;
  616.     return;
  617.   }
  618.  
  619.   if (SetBaud(word) == False)
  620.     eof_flag++;
  621. }
  622.  
  623. void
  624. set_port()
  625. {
  626.   SeNotice("/sp/ Sorry, \"set port\" is not supported in this release");
  627.   return;
  628.  
  629.   getword();
  630.   if (word[0] == '\0') {
  631.     SeError("'set port' must specify modem device");
  632.     eof_flag++;
  633.     return;
  634.   }
  635.  
  636.   if (SetPort(word) == False)
  637.     eof_flag++;
  638. }
  639.  
  640. struct param {
  641.   Boolean         autoZmodem;
  642.   Boolean         idleGuard;
  643.   Boolean         stripHighBit;
  644.   Boolean         backspaceTranslation;
  645.   Boolean         metaKeyTranslation;
  646.   Boolean         xonxoffFlowControl;
  647.   Boolean         rtsctsFlowControl;
  648.   int             newlineTrMode;
  649.  
  650. };
  651.  
  652. int
  653. PutParameters(destination)
  654.      int *destination;
  655. {
  656.   struct param    param;
  657.   int             writeRetStatus;
  658.  
  659.   param.idleGuard = qres.idleGuard;
  660.   param.stripHighBit = qres.stripHighBit;
  661.   param.backspaceTranslation = qres.backspaceTranslation;
  662.   param.metaKeyTranslation = qres.metaKeyTranslation;
  663.   param.xonxoffFlowControl = qres.xonxoffFlowControl;
  664.   param.rtsctsFlowControl = qres.rtsctsFlowControl;
  665.   param.autoZmodem = qres.autoZmodem;
  666.   param.newlineTrMode = newlineTrMode;
  667.  
  668.   if ((writeRetStatus = write(destination[1], (char*)¶m, sizeof(param)))
  669.       == -1)
  670.     SePError("Could not write to pipe");
  671.   
  672.   return writeRetStatus;
  673. }
  674.  
  675. void
  676. GetParameters(clientData, source)
  677.      XtPointer  clientData;
  678.      int       *source;
  679. {
  680.   struct param    param;
  681.  
  682.   if (read(source[0], (char*)¶m, sizeof(param)) == -1)
  683.     SePError("Could not read from pipe");
  684.  
  685.   qres.idleGuard = param.idleGuard;
  686.   qres.stripHighBit = param.stripHighBit;
  687.   qres.backspaceTranslation = param.backspaceTranslation;
  688.   qres.metaKeyTranslation = param.metaKeyTranslation;
  689.   qres.xonxoffFlowControl = param.xonxoffFlowControl;
  690.   qres.rtsctsFlowControl = param.rtsctsFlowControl;
  691.   qres.autoZmodem = param.autoZmodem;
  692.   newlineTrMode = param.newlineTrMode;
  693.  
  694.   get_modem_attr();
  695. }
  696.